package tabla;
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

import apunte.Apunte;
import apunte.Carrera;
import apunte.Materia;
import apunte.Profesor;
import java.util.Iterator;
import javax.swing.table.*;
import javax.swing.event.*;
import java.util.LinkedList;

/** 
 * Modelo de Apuntes. Cada fila es una Apunte y las columnas son los datos
 * de la Apunte.
 * Implementa TableModel y dos métodos para añadir y eliminar Apuntes del
 * modelo 
 */
public class ModeloTabla implements TableModel {

    /** Returns the number of columns in the model. A
     * <code>JTable</code> uses this method to determine how many columns it
     * should create and display by default.
     *
     * @return the number of columns in the model
     * @see #getRowCount
     *
     */
    public int getColumnCount() {
        // Devuelve el número de columnas del modelo, que coincide con el
        // número de datos que tenemos de cada Apunte.
        return 10;
        
    }

    /** Returns the number of rows in the model. A
     * <code>JTable</code> uses this method to determine how many rows it
     * should display.  This method should be quick, as it
     * is called frequently during rendering.
     *
     * @return the number of rows in the model
     * @see #getColumnCount
     *
     */
    public int getRowCount() {
        // Devuelve el número de Apuntes en el modelo, es decir, el número
        // de filas en la tabla.
        return datos.size();
    }

    /** Returns the value for the cell at <code>columnIndex</code> and
     * <code>rowIndex</code>.
     *
     * @param	rowIndex	the row whose value is to be queried
     * @param	columnIndex 	the column whose value is to be queried
     * @return	the value Object at the specified cell
     *
     */
    public Object getValueAt(int rowIndex, int columnIndex) {
        Apunte aux;

        // Se obtiene la Apunte de la fila indicada
        aux = (Apunte) (datos.get(rowIndex));

        // Se obtiene el campo apropiado según el valor de columnIndex
        switch (columnIndex) {
            case 0:
                return aux.getIdapunte();
            case 1:
                return aux.getNombreApunte();
            case 2:
                return aux.getTema();
            case 3:
                LinkedList<Profesor> profesor = aux.getProfesor();
                
                if (profesor != null){
                Iterator<Profesor> i = profesor.iterator();


                String resultado = "";
                while (i.hasNext()) {
                    Profesor next = i.next();

                    resultado += " " + next.getNombre() + " ";

                }

                return resultado;
                }else {
                    return null;
                }
            case 4:
        Materia materia = aux.getMateria();
                if (materia != null){
                    return materia.getNombreMateria();
                    
                }else {
                    return null;
                }

            case 5:
                LinkedList<Carrera> carrera = aux.getCarrera();
                
                if (carrera !=  null){
                
                Iterator<Carrera> iterator = carrera.iterator();
                String resultadoCarrera = "";
                while (iterator.hasNext()) {
                    Carrera next = iterator.next();

                    resultadoCarrera += " " + next.getNombreCarrera() + " ";
                }
                return resultadoCarrera;
                }else {
                    return null;
                }
                

            case 6:
                return aux.getPrecio();

            case 7:
                return aux.getCantidad();

            case 8:
                return aux.getUbicacion();

            case 9:
                return aux.getDescripcion();
            case 10:
                return aux.getLetra();

            default:
                return null;
        }
    }

    /**
     * Borra del modelo la Apunte en la fila indicada 
     */
    public void borraApunte(int fila) {
        // Se borra la fila 
        datos.remove(fila);

        // Y se avisa a los suscriptores, creando un TableModelEvent...
        TableModelEvent evento = new TableModelEvent(this, fila, fila,
                TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);

        // ... y pasándoselo a los suscriptores
        avisaSuscriptores(evento);
    }

    /**
     * Añade una Apunte al final de la tabla
     */
    public void anhadeApunte(Apunte nuevaApunte) {
        // Añade la Apunte al modelo 
        datos.add(nuevaApunte);

        // Avisa a los suscriptores creando un TableModelEvent...
        TableModelEvent evento;
        evento = new TableModelEvent(this, this.getRowCount() - 1,
                this.getRowCount() - 1, TableModelEvent.ALL_COLUMNS,
                TableModelEvent.INSERT);

        // ... y avisando a los suscriptores
        avisaSuscriptores(evento);
    }

    /** Adds a listener to the list that is notified each time a change
     * to the data model occurs.
     *
     * @param	l		the TableModelListener
     *
     */
    public void addTableModelListener(TableModelListener l) {
        // Añade el suscriptor a la lista de suscriptores
        listeners.add(l);
    }

    /** Returns the most specific superclass for all the cell values
     * in the column.  This is used by the <code>JTable</code> to set up a
     * default renderer and editor for the column.
     *
     * @param columnIndex  the index of the column
     * @return the common ancestor class of the object values in the model.
     *
     */
    public Class getColumnClass(int columnIndex) {
        // Devuelve la clase que hay en cada columna.
        switch (columnIndex) {
            case 0:
                // La columna cero contiene el nombre de la Apunte, que es
                // un String
                return String.class;
            case 1:
                // La columna uno contiene el apellido de la Apunte, que es
                // un String
                return String.class;
            case 2:
                // La columna dos contine la edad de la Apunte, que es un
                // Integer (no vale int, debe ser una clase)
                return Integer.class;

            case 3:
                return String.class;
            case 4:
                return String.class;
            case 5:
                return String.class;
            case 6:
                return String.class;
            case 7:
                return String.class;
            case 8:
                return String.class;
            case 9:
                return String.class;
            case 10:
                return String.class;
            default:
                // Devuelve una clase Object por defecto.
                return Object.class;
        }
    }

    /** Returns the name of the column at <code>columnIndex</code>.  This is used
     * to initialize the table's column header name.  Note: this name does
     * not need to be unique; two columns in a table can have the same name.
     *
     * @param	columnIndex	the index of the column
     * @return  the name of the column
     *
     */
    public String getColumnName(int columnIndex) {
        // Devuelve el nombre de cada columna. Este texto aparecerá en la
        // cabecera de la tabla.
        switch (columnIndex) {
            case 0:
                return "Id Apunte";
            case 1:
                return "Nombre Apunte";
            case 2:
                return "Tema";
            case 3:
                return "Profesor";
            case 4:
                return "Materia";
            case 5:
                return "Carrera";
            case 6:
                return "Precio";
            case 7:
                return "Cantidad";
            case 8:
                return "Ubicacion";
            case 9:
                return "Descripcion";
            case 10:
                return "Codigo";
            default:
                return null;
        }
    }

    /** Returns true if the cell at <code>rowIndex</code> and
     * <code>columnIndex</code>
     * is editable.  Otherwise, <code>setValueAt</code> on the cell will not
     * change the value of that cell.
     *
     * @param	rowIndex	the row whose value to be queried
     * @param	columnIndex	the column whose value to be queried
     * @return	true if the cell is editable
     * @see #setValueAt
     *
     */
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        // Permite que la celda sea editable.
        return false;
    }

    /** Removes a listener from the list that is notified each time a
     * change to the data model occurs.
     *
     * @param	l		the TableModelListener
     *
     */
    public void removeTableModelListener(TableModelListener l) {
        // Elimina los suscriptores.
        listeners.remove(l);
    }

    /** Sets the value in the cell at <code>columnIndex</code> and
     * <code>rowIndex</code> to <code>aValue</code>.
     *
     * @param	aValue		 the new value
     * @param	rowIndex	 the row whose value is to be changed
     * @param	columnIndex 	 the column whose value is to be changed
     * @see #getValueAt
     * @see #isCellEditable
     *
     */
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        // Obtiene la Apunte de la fila indicada
        Apunte aux;
        aux = (Apunte) (datos.get(rowIndex));

        // Cambia el campo de Apunte que indica columnIndex, poniendole el 
        // aValue que se nos pasa.
        switch (columnIndex) {
            case 0:

                break;
            case 1:
                aux.setNombreApunte((String) aValue);
                break;
            case 2:
                aux.setTema((String) aValue);
                break;
            case 3:

                break;
            case 4:
                break;
            case 5:
                break;
            case 6:
                aux.setPrecio((String) aValue);
            case 7: 
                aux.setCantidad(Integer.parseInt(aValue.toString()));
            case 8:
                aux.setUbicacion((String) aValue);
            case 9:
                aux.setDescripcion((String) aValue);
            case 10:
                aux.setLetra((String) aValue);
            default:
                break;
        }

        // Avisa a los suscriptores del cambio, creando un TableModelEvent ...
        TableModelEvent evento = new TableModelEvent(this, rowIndex, rowIndex,
                columnIndex);

        // ... y pasándoselo a los suscriptores.
        avisaSuscriptores(evento);
    }

    /**
     * Pasa a los suscriptores el evento.
     */
    private void avisaSuscriptores(TableModelEvent evento) {
        int i;

        // Bucle para todos los suscriptores en la lista, se llama al metodo
        // tableChanged() de los mismos, pasándole el evento.
        for (i = 0; i < listeners.size(); i++) {
            ((TableModelListener) listeners.get(i)).tableChanged(evento);
        }
    }
    /** Lista con los datos. Cada elemento de la lista es una instancia de
     * Apunte */
    private LinkedList datos = new LinkedList();
    /** Lista de suscriptores. El JTable será un suscriptor de este modelo de
     * datos */
    private LinkedList listeners = new LinkedList();
}